{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "import argparse\n",
        "from pathlib import Path\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error\n",
        "\n",
        "import mlflow\n",
        "import mlflow.sklearn\n",
        "import mlflow.pyfunc\n",
        "from mlflow.tracking import MlflowClient"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "TARGET_COL = \"cost\"\n",
        "\n",
        "NUMERIC_COLS = [\n",
        "    \"distance\",\n",
        "    \"dropoff_latitude\",\n",
        "    \"dropoff_longitude\",\n",
        "    \"passengers\",\n",
        "    \"pickup_latitude\",\n",
        "    \"pickup_longitude\",\n",
        "    \"pickup_weekday\",\n",
        "    \"pickup_month\",\n",
        "    \"pickup_monthday\",\n",
        "    \"pickup_hour\",\n",
        "    \"pickup_minute\",\n",
        "    \"pickup_second\",\n",
        "    \"dropoff_weekday\",\n",
        "    \"dropoff_month\",\n",
        "    \"dropoff_monthday\",\n",
        "    \"dropoff_hour\",\n",
        "    \"dropoff_minute\",\n",
        "    \"dropoff_second\",\n",
        "]\n",
        "\n",
        "CAT_NOM_COLS = [\n",
        "    \"store_forward\",\n",
        "    \"vendor\",\n",
        "]\n",
        "\n",
        "CAT_ORD_COLS = [\n",
        "]\n",
        "\n",
        "SENSITIVE_COLS = [\"vendor\"] # for fairlearn dashborad\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "# Define Arguments for this step\n",
        "\n",
        "class MyArgs:\n",
        "    def __init__(self, /, **kwargs):\n",
        "        self.__dict__.update(kwargs)\n",
        "\n",
        "args = MyArgs(\n",
        "                model_name = \"taxi-model\",\n",
        "                model_input = \"/tmp/train\",\n",
        "                test_data = \"/tmp/prep/train\",\n",
        "                evaluation_output = \"/tmp/evaluate\",\n",
        "                runner = \"LocalRunner\"\n",
        "                )\n",
        "\n",
        "os.makedirs(args.evaluation_output, exist_ok = True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "\n",
        "def main(args):\n",
        "    '''Read trained model and test dataset, evaluate model and save result'''\n",
        "\n",
        "    # Load the test data\n",
        "    test_data = pd.read_parquet(Path(args.test_data))\n",
        "\n",
        "    # Split the data into inputs and outputs\n",
        "    y_test = test_data[TARGET_COL]\n",
        "    X_test = test_data[NUMERIC_COLS + CAT_NOM_COLS + CAT_ORD_COLS]\n",
        "\n",
        "    # Load the model from input port\n",
        "    model =  mlflow.sklearn.load_model(args.model_input) \n",
        "\n",
        "    # ---------------- Model Evaluation ---------------- #\n",
        "    yhat_test, score = model_evaluation(X_test, y_test, model, args.evaluation_output)\n",
        "\n",
        "    # ----------------- Model Promotion ---------------- #\n",
        "    if args.runner == \"CloudRunner\":\n",
        "        predictions, deploy_flag = model_promotion(args.model_name, args.evaluation_output, X_test, y_test, yhat_test, score)\n",
        "\n",
        "\n",
        "\n",
        "def model_evaluation(X_test, y_test, model, evaluation_output):\n",
        "\n",
        "    # Get predictions to y_test (y_test)\n",
        "    yhat_test = model.predict(X_test)\n",
        "\n",
        "    # Save the output data with feature columns, predicted cost, and actual cost in csv file\n",
        "    output_data = X_test.copy()\n",
        "    output_data[\"real_label\"] = y_test\n",
        "    output_data[\"predicted_label\"] = yhat_test\n",
        "    output_data.to_csv((Path(evaluation_output) / \"predictions.csv\"))\n",
        "\n",
        "    # Evaluate Model performance with the test set\n",
        "    r2 = r2_score(y_test, yhat_test)\n",
        "    mse = mean_squared_error(y_test, yhat_test)\n",
        "    rmse = np.sqrt(mse)\n",
        "    mae = mean_absolute_error(y_test, yhat_test)\n",
        "\n",
        "    # Print score report to a text file\n",
        "    (Path(evaluation_output) / \"score.txt\").write_text(\n",
        "        f\"Scored with the following model:\\n{format(model)}\"\n",
        "    )\n",
        "    with open((Path(evaluation_output) / \"score.txt\"), \"a\") as outfile:\n",
        "        outfile.write(\"Mean squared error: {mse.2f} \\n\")\n",
        "        outfile.write(\"Root mean squared error: {rmse.2f} \\n\")\n",
        "        outfile.write(\"Mean absolute error: {mae.2f} \\n\")\n",
        "        outfile.write(\"Coefficient of determination: {r2.2f} \\n\")\n",
        "\n",
        "    mlflow.log_metric(\"test r2\", r2)\n",
        "    mlflow.log_metric(\"test mse\", mse)\n",
        "    mlflow.log_metric(\"test rmse\", rmse)\n",
        "    mlflow.log_metric(\"test mae\", mae)\n",
        "\n",
        "    # Visualize results\n",
        "    plt.scatter(y_test, yhat_test,  color='black')\n",
        "    plt.plot(y_test, y_test, color='blue', linewidth=3)\n",
        "    plt.xlabel(\"Real value\")\n",
        "    plt.ylabel(\"Predicted value\")\n",
        "    plt.title(\"Comparing Model Predictions to Real values - Test Data\")\n",
        "    plt.savefig(\"predictions.png\")\n",
        "    mlflow.log_artifact(\"predictions.png\")\n",
        "\n",
        "    return yhat_test, r2\n",
        "\n",
        "def model_promotion(model_name, evaluation_output, X_test, y_test, yhat_test, score):\n",
        "    \n",
        "    scores = {}\n",
        "    predictions = {}\n",
        "\n",
        "    client = MlflowClient()\n",
        "\n",
        "    for model_run in client.search_model_versions(f\"name='{model_name}'\"):\n",
        "        model_version = model_run.version\n",
        "        mdl = mlflow.pyfunc.load_model(\n",
        "            model_uri=f\"models:/{model_name}/{model_version}\")\n",
        "        predictions[f\"{model_name}:{model_version}\"] = mdl.predict(X_test)\n",
        "        scores[f\"{model_name}:{model_version}\"] = r2_score(\n",
        "            y_test, predictions[f\"{model_name}:{model_version}\"])\n",
        "\n",
        "    if scores:\n",
        "        if score >= max(list(scores.values())):\n",
        "            deploy_flag = 1\n",
        "        else:\n",
        "            deploy_flag = 0\n",
        "    else:\n",
        "        deploy_flag = 1\n",
        "    print(f\"Deploy flag: {deploy_flag}\")\n",
        "\n",
        "    with open((Path(evaluation_output) / \"deploy_flag\"), 'w') as outfile:\n",
        "        outfile.write(f\"{int(deploy_flag)}\")\n",
        "\n",
        "    # add current model score and predictions\n",
        "    scores[\"current model\"] = score\n",
        "    predictions[\"currrent model\"] = yhat_test\n",
        "\n",
        "    perf_comparison_plot = pd.DataFrame(\n",
        "        scores, index=[\"r2 score\"]).plot(kind='bar', figsize=(15, 10))\n",
        "    perf_comparison_plot.figure.savefig(\"perf_comparison.png\")\n",
        "    perf_comparison_plot.figure.savefig(Path(evaluation_output) / \"perf_comparison.png\")\n",
        "\n",
        "    mlflow.log_metric(\"deploy flag\", bool(deploy_flag))\n",
        "    mlflow.log_artifact(\"perf_comparison.png\")\n",
        "\n",
        "    return predictions, deploy_flag"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model name: taxi-model\n",
            "Model path: /tmp/train\n",
            "Test data path: /tmp/prep/train\n",
            "Evaluation output path: /tmp/evaluate\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "mlflow.start_run()\n",
        "\n",
        "lines = [\n",
        "    f\"Model name: {args.model_name}\",\n",
        "    f\"Model path: {args.model_input}\",\n",
        "    f\"Test data path: {args.test_data}\",\n",
        "    f\"Evaluation output path: {args.evaluation_output}\",\n",
        "]\n",
        "\n",
        "for line in lines:\n",
        "    print(line)\n",
        "\n",
        "main(args)\n",
        "\n",
        "mlflow.end_run()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "vscode": {
          "languageId": "shellscript"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " Volume in drive C is Local Disk\n",
            " Volume Serial Number is 583C-74B4\n",
            "\n",
            " Directory of c:\\tmp\\evaluate\n",
            "\n",
            "10/07/2022  10:26 AM    <DIR>          .\n",
            "10/07/2022  10:26 AM    <DIR>          ..\n",
            "10/07/2022  10:42 AM           970,963 predictions.csv\n",
            "10/07/2022  10:42 AM               320 score.txt\n",
            "               2 File(s)        971,283 bytes\n",
            "               2 Dir(s)  787,572,764,672 bytes free\n"
          ]
        }
      ],
      "source": [
        "ls \"/tmp/evaluate\""
      ]
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python38-azureml"
    },
    "kernelspec": {
      "display_name": "Python 3.9.6 64-bit",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.6"
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    },
    "vscode": {
      "interpreter": {
        "hash": "c87d6401964827bd736fe8e727109b953dd698457ca58fb5acabab22fd6dac41"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
